package org.nw.exp;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import nc.vo.pub.AggregatedValueObject;
import nc.vo.pub.CircularlyAccessibleValueObject;
import nc.vo.pub.SuperVO;
import nc.vo.pub.VOStatus;
import nc.vo.pub.lang.UFBoolean;
import nc.vo.pub.lang.UFDate;
import nc.vo.pub.lang.UFDateTime;
import nc.vo.pub.lang.UFDouble;
import nc.vo.trade.pub.IExAggVO;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.nw.constants.Constants;
import org.nw.dao.NWDao;
import org.nw.exception.BusiException;
import org.nw.jf.UiConstants;
import org.nw.jf.UiConstants.DATATYPE;
import org.nw.jf.ext.ref.BaseRefModel;
import org.nw.jf.ext.ref.userdefine.IMultiSelect;
import org.nw.jf.utils.DataTypeConverter;
import org.nw.jf.utils.UiTempletUtils;
import org.nw.jf.vo.BillTempletBVO;
import org.nw.jf.vo.UiBillTempletVO;
import org.nw.service.IToftService;
import org.nw.utils.RefUtils;
import org.nw.vo.HYBillVO;
import org.nw.vo.ParamVO;
import org.nw.vo.RefVO;
import org.nw.vo.VOTableVO;
import org.nw.vo.sys.ImportColumnVO;
import org.nw.web.utils.WebUtils;

import com.uft.webnc.util.DateUtils;
import com.uft.webnc.util.ReflectionUtils;

/**
 * excel导入器，只适合导入单表头的档案
 * 
 * @author xuqc
 * @date 2013-8-15 下午10:43:50
 */
public class ExcelImporter {

	protected Logger logger = Logger.getLogger(ExcelImporter.class);

	// 参数
	public ParamVO paramVO;

	public void setParamVO(ParamVO paramVO) {
		this.paramVO = paramVO;
	}

	public ExcelImporter() {

	}

	public ExcelImporter(ParamVO paramVO, IToftService service) {
		this.paramVO = paramVO;
		this.service = service;
		this.initColumnDefineMap();// 初始化列对照关系
		billInfo = this.service.getBillInfo();
	}

	// 当数据整理完成后，需要调用service类进行保存
	public IToftService service;

	public AggregatedValueObject billInfo;

	public void setService(IToftService service) {
		this.service = service;
		billInfo = this.service.getBillInfo();
	}

	// 导入过程中产生的警告信息
	protected StringBuffer logBuf = new StringBuffer();

	protected int importNum = 0;// 导入的个数

	/**
	 * 返回导入过程所产生的日志
	 * 
	 * @return
	 */
	public String getLog() {
		return logBuf.toString();
	}

	// 校验类的map
	public Map<String, ImportChecker> checkerMap = new HashMap<String, ImportChecker>();

	/**
	 * 列对照关系
	 */
	public Map<String, ImportColumnVO> importColumnMap = new HashMap<String, ImportColumnVO>();

	/**
	 * 下载模板文件
	 * 
	 * @param request
	 * @param response
	 * @param templetFile
	 * @throws IOException
	 */
	public void downladTemplet(HttpServletRequest request, HttpServletResponse response, String templetFile)
			throws IOException {
		if(StringUtils.isBlank(templetFile)) {
			throw new BusiException("模板文件的名称不能为空！");
		}
		response.setContentType("application/octet-stream");
		response.setHeader("Pragma", "No-cache");
		response.setHeader("Cache-Control", "no-cache");
		response.setDateHeader("Expires", 0);
		response.setContentType("application/octet-stream");
		response.setHeader("Content-Disposition", "attachment;filename=\""
				+ new String(templetFile.getBytes(), "ISO-8859-1") + "\"");
		String basePath = request.getSession().getServletContext().getRealPath("/");
		basePath += File.separator + "WEB-INF" + File.separator + "resources" + File.separator + "import_template";
		File destFile = new File(basePath + File.separator + templetFile);
		if(!destFile.exists()) {
			throw new BusiException("文件不存在,目录：" + basePath + "！");
		}
		/* 创建输出流 */
		ServletOutputStream servletOS = response.getOutputStream();
		FileInputStream inputStream = new FileInputStream(destFile);
		byte[] buf = new byte[1024];
		int readLength;
		while(((readLength = inputStream.read(buf)) != -1)) {
			servletOS.write(buf, 0, readLength);
		}
		inputStream.close();
		servletOS.flush();
		servletOS.close();
	}

	/**
	 * 返回导入的列定义的map
	 * 
	 * @param paramVO
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	protected void initColumnDefineMap() {
		ImportColumnVO[] vos = NWDao.getInstance().queryForSuperVOArrayByCondition(ImportColumnVO.class,
				"isnull(dr,0)=0 and fun_code=?", paramVO.getFunCode());
		if(vos != null && vos.length > 0) {
			for(ImportColumnVO vo : vos) {
				importColumnMap.put(vo.getField_name(), vo);
				String checker = vo.getChecker();
				if(StringUtils.isNotBlank(checker)) {
					try {
						Class clazz = Class.forName(checker);
						checkerMap.put(vo.getField_code(), (ImportChecker) clazz.newInstance());
					} catch(Exception e) {
						logger.warn("导入的校验类实例化失败，类名称：" + checker);
						throw new BusiException("导入的校验类实例化失败，类名称：" + checker);
					}
				}
			}
		} else {
			throw new BusiException("没有设置列对照关系！");
		}
	}

	/**
	 * 导入一个sheet的数据，返回vo集合
	 * 
	 * @param sheet
	 * @param templetVO
	 * @return
	 */
	protected List<AggregatedValueObject> resolve(Sheet sheet, Map<String, BillTempletBVO> itemMap) {
		List<AggregatedValueObject> aggVOs = new ArrayList<AggregatedValueObject>();// excel文件的数据转换成的vo集合
		int rowNum = sheet.getLastRowNum() + 1; // 得到总行数,这里的总行数是从0开始的,+1
		Row headerRow = sheet.getRow(0); // 标题行
		int colNum = headerRow.getPhysicalNumberOfCells();// 列数。
		for(int i = 1; i < rowNum; i++) {
			Row row = sheet.getRow(i); // 正文行
			if(row == null) {
				continue;
			}
			SuperVO parentVO = getParentVO();// 每一行对应一个VO
			int j = 0;
			while(j < colNum) {
				String title = getStringCellValue(headerRow.getCell(j)).trim();// excel文件的标题栏
				if(StringUtils.isBlank(title)) {
					// 如果标题栏为空，忽略该列，比如是序号列
					j++;
					continue;
				}
				ImportColumnVO importColumnVO = importColumnMap.get(title);
				if(importColumnVO == null) {
					j++;
					continue;
				}
				String fieldCode = importColumnVO.getField_code();// 导入字段中定义的字段编码
				BillTempletBVO fieldVO = itemMap.get(fieldCode);
				String value = getStringCellValue(row.getCell(j)).trim();// excel文件中的字段的值
				Object realValue;
				if(fieldVO == null) {
					// 模板中没有对应的字段，那么看看这个字段是否是ＶＯ的一个成员变量
					Field field = ReflectionUtils.findField(parentVO.getClass(), fieldCode);
					if(field == null) {
						j++;
						continue;
					} else {
						// 是成员变量，那么根据变量类型去设置值，对于成员变量，不需要调用检测接口
						realValue = getRealValue(value, field);
					}
				} else {
					realValue = getRealValue(value, fieldVO, parentVO);// 根据数据类型转换后的值
					ImportChecker checker = this.checkerMap.get(fieldCode);
					if(realValue != null && checker != null) {
						checker.setService(this.service);
						String warnMsg = checker.check(realValue, fieldVO);
						if(StringUtils.isNotBlank(warnMsg)) {
							// 该数据不是有效的数据,这里要区分,如果是关键数据,那么整行都不导入,否则该字段不导入即可
							if(importColumnVO.getKeyfield_flag() != null
									&& importColumnVO.getKeyfield_flag().booleanValue()) {
								// 关键字段，忽略该行
								j++;
								parentVO = null;// 将superVO设置成null,以便不加入
								logBuf.append("第" + i + "行的[" + title + ":" + value + "]数据有误,错误信息：" + warnMsg + "\n");
								break;
							} else {
								// 不是关键字段，设置为null值
								realValue = null;
							}
						}
					}
				}
				setValueToSuperVO(fieldVO, parentVO, fieldCode, realValue);
				j++;
			}
			if(parentVO != null) {
				processAfterResolveOneRow(parentVO, aggVOs);
			}
		}
		if(aggVOs.size() > 0) {
			execFormula(aggVOs);
		}
		importNum = aggVOs.size();
		logBuf.append("共识别到" + importNum + "条记录！\n");
		return aggVOs;
	}

	/**
	 * 识别一行后执行的动作
	 * 
	 * @param parentVO
	 * @param aggVOs
	 */
	public void processAfterResolveOneRow(SuperVO parentVO, List<AggregatedValueObject> aggVOs) {
		if(parentVO != null) {
			parentVO.setStatus(VOStatus.NEW);
			NWDao.setUuidPrimaryKey(parentVO);
			AggregatedValueObject aggVO = new HYBillVO();
			aggVO.setParentVO(parentVO);
			aggVOs.add(aggVO);
		}
	}

	/**
	 * 为属性设置值，如果是参照需要做点特殊处理
	 * 
	 * @param fieldVO
	 * @param superVO
	 * @param fieldCode
	 * @param realValue
	 */
	protected void setValueToSuperVO(BillTempletBVO fieldVO, SuperVO superVO, String fieldCode, Object realValue) {
		if(realValue == null) {
			return;
		}
		if(realValue instanceof RefVO) {
			RefVO refVO = (RefVO) realValue;
			superVO.setAttributeValue(fieldVO.getIdcolname() == null ? fieldCode : fieldVO.getIdcolname(),
					refVO.getPk());
		} else {
			superVO.setAttributeValue(fieldCode, realValue);
		}
	}

	/**
	 * 设置值到superVO中，根据字段类型进行转换
	 * 
	 * @param superVO
	 * @param fieldName
	 * @param value
	 */
	protected void setValueToSuperVO(SuperVO superVO, String fieldName, Object value) {
		Field field = ReflectionUtils.findField(superVO.getClass(), fieldName);
		if(field != null) {
			Object realValue = null;
			if(value != null) {
				realValue = getRealValue(value.toString(), field);
			}
			superVO.setAttributeValue(fieldName, realValue);
		}
	}

	/**
	 * 解析excel文件，返回superVO
	 * 
	 * @param file
	 * @return
	 * @throws Exception
	 */
	public List<AggregatedValueObject> resolve(File file) throws Exception {
		if(file == null) {
			throw new BusiException("没有选择要导入的文件！");
		}
		if(service == null) {
			throw new BusiException("导入模板时需要注入Service类！");
		}
		InputStream input = null;
		Workbook wb = null;
		try {
			UiBillTempletVO templetVO = this.service.getBillTempletVOByFunCode(paramVO);
			Map<String, BillTempletBVO> itemMap = getBillTempletVOMap(templetVO);
			input = new FileInputStream(file);
			wb = WorkbookFactory.create(input);
			Sheet sheet = wb.getSheetAt(0);
			return resolve(sheet, itemMap);
		} finally {
			try {
				input.close();
			} catch(Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 导入excel数据
	 * 
	 * @param file
	 * @return
	 */
	public void _import(File file) throws Exception {
		List<AggregatedValueObject> aggVOs = resolve(file);
		if(aggVOs != null && aggVOs.size() > 0) {
			for(AggregatedValueObject billVO : aggVOs) {
				processBeforeImport(billVO, paramVO);
				this.service.save(billVO, paramVO);
			}
			logBuf.append("共导入" + importNum + "记录");
			logger.info(logBuf.toString());
		}
	}

	/**
	 * 导入时候的保存前动作
	 * 
	 * @param billVO
	 * @param paramVO
	 */
	protected void processBeforeImport(AggregatedValueObject billVO, ParamVO paramVO) {
		// 设置公司字段
		CircularlyAccessibleValueObject parentVO = billVO.getParentVO();
		if(parentVO != null) {
			Field field = ReflectionUtils.findField(parentVO.getClass(), "pk_corp");
			if(field != null) {
				parentVO.setAttributeValue("pk_corp", WebUtils.getLoginInfo().getPk_corp());
			}
		}
	}

	/**
	 * 返回vo的一个实例
	 * 
	 * @return
	 */
	@SuppressWarnings("unchecked")
	protected SuperVO getParentVO() {
		try {
			Class<? extends SuperVO> voClass = (Class<? extends SuperVO>) Class.forName(billInfo.getParentVO()
					.getAttributeValue(VOTableVO.HEADITEMVO).toString().trim());
			return voClass.newInstance();
		} catch(Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 返回单据模板中字段的map对象，以itemkey作为key。如果是表体，那么tabcode作为前缀，如ts_inv_pack_b.
	 * goods_code
	 * 
	 * @param paramVO
	 * @return
	 */
	protected Map<String, BillTempletBVO> getBillTempletVOMap(UiBillTempletVO templetVO) {
		List<BillTempletBVO> fieldVOs = templetVO.getFieldVOs();
		Map<String, BillTempletBVO> itemMap = new HashMap<String, BillTempletBVO>();
		for(BillTempletBVO fieldVO : fieldVOs) {
			if(fieldVO.getPos().intValue() == UiConstants.POS[0]) {
				itemMap.put(fieldVO.getItemkey(), fieldVO);
			} else {
				String table_code = fieldVO.getTable_code();
				itemMap.put(table_code + "." + fieldVO.getItemkey(), fieldVO);
			}
		}
		return itemMap;
	}

	/**
	 * 返回模板的编辑公式，导入时需要同时执行编辑公式
	 * 
	 * @param templetVO
	 * @return
	 */
	protected String[] getFormulaAry(Map<String, BillTempletBVO> itemMap, int pos, String tabcode) {
		List<String> formulaAry = new ArrayList<String>();
		Iterator<BillTempletBVO> it = itemMap.values().iterator();
		while(it.hasNext()) {
			BillTempletBVO fieldVO = it.next();
			if(StringUtils.isNotBlank(tabcode)) {
				if(!fieldVO.getTable_code().equals(tabcode)) {
					continue;
				}
			}
			if(fieldVO.getPos().intValue() == pos) {
				if(StringUtils.isNotBlank(fieldVO.getEditformula())) {
					formulaAry.add(fieldVO.getEditformula());
				}
			}
		}
		return formulaAry.toArray(new String[formulaAry.size()]);
	}

	@SuppressWarnings("unchecked")
	protected void execFormula(List<AggregatedValueObject> aggVOs) {
		if(aggVOs != null && aggVOs.size() > 0) {
			// 执行公式，并将执行公式后的值设置到vo中，保存vo
			for(AggregatedValueObject billVO : aggVOs) {
				Map<String, Object> retMap = this.service.execFormula4Templet(billVO, paramVO);
				SuperVO parentVO = (SuperVO) billVO.getParentVO();
				if(parentVO != null) {
					// 存在表头
					Map<String, Object> headerMap = (Map<String, Object>) retMap.get(Constants.HEADER);
					for(String key : headerMap.keySet()) {
						Object obj = headerMap.get(key);
						if(obj instanceof RefVO) {
							RefVO refVO = (RefVO) obj;
							parentVO.setAttributeValue(key, refVO.getPk());
						} else {
							setValueToSuperVO(parentVO, key, headerMap.get(key));
						}
					}
				}
				CircularlyAccessibleValueObject[] childVOs = null;
				if(billVO instanceof IExAggVO) {
					// 多子表
					String[] tableCodes = ((IExAggVO) billVO).getTableCodes();
					for(String tableCode : tableCodes) {
						CircularlyAccessibleValueObject[] cvos = ((IExAggVO) billVO).getTableVO(tableCode);
						if(cvos != null && cvos.length > 0) {
							childVOs = cvos;
						}
					}
				} else {
					childVOs = billVO.getChildrenVO();
				}
				if(childVOs != null && childVOs.length > 0) {
					Map<String, Object> bodyMap = (Map<String, Object>) retMap.get(Constants.BODY);
					String table_name = ((SuperVO) childVOs[0]).getTableName();// 这里的table_name必须和模板中tabcode对应
					List<Map<String, Object>> bodyList = (List<Map<String, Object>>) bodyMap.get(table_name);
					for(int i = 0; i < childVOs.length; i++) {
						SuperVO childVO = (SuperVO) childVOs[i];
						Map<String, Object> rowMap = bodyList.get(i);
						for(String key : rowMap.keySet()) {
							Object obj = rowMap.get(key);
							if(obj instanceof RefVO) {
								RefVO refVO = (RefVO) obj;
								childVO.setAttributeValue(key, refVO.getPk());
							} else {
								setValueToSuperVO(childVO, key, rowMap.get(key));
							}
						}
					}
				}
			}
		}
	}

	/**
	 * 返回根据ＶＯ中成员变量的类型的值
	 * 
	 * @param value
	 * @param field
	 * @return
	 */
	protected Object getRealValue(String value, Field field) {
		if(StringUtils.isBlank(value)) {
			return null;
		}
		Object realValue = value;
		if(field.getType() == Integer.class) {
			if(StringUtils.isBlank(value)) {
				value = "0";
			}
			if(value.indexOf(".") != -1) {
				// 包括小数点，直接去掉小数点
				value = value.substring(0, value.indexOf("."));
			}
			realValue = Integer.parseInt(value);
		} else if(field.getType() == UFDouble.class) {
			if(StringUtils.isBlank(value)) {
				value = "0";
			}
			realValue = new UFDouble(value);
		} else if(field.getType() == UFDate.class) {
			realValue = new UFDate(value);
		} else if(field.getType() == UFDateTime.class) {
			realValue = new UFDateTime(value);
		} else if(field.getType() == UFBoolean.class) {
			if(Constants.Y.equalsIgnoreCase(value)) {
				realValue = UFBoolean.TRUE;
			} else {
				realValue = UFBoolean.FALSE;
			}
		}
		return realValue;
	}

	/**
	 * 根据模板中的培训，将excel中设置的值转成实际可以设置到数据库中的值
	 * 
	 * @param value
	 * @param fieldVO
	 * @param superVO
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	protected Object getRealValue(String value, BillTempletBVO fieldVO, SuperVO superVO) {
		if(StringUtils.isBlank(value)) {
			return null;
		}
		Object realValue = value;
		try {
			if(DATATYPE.INTEGER.equals(fieldVO.getDatatype())) {
				if(StringUtils.isBlank(value)) {
					value = "0";
				}
				if(value.indexOf(".") != -1) {
					// 包括小数点，直接去掉小数点
					value = value.substring(0, value.indexOf("."));
				}
				realValue = Integer.parseInt(value);
			} else if(DATATYPE.DECIMAL.equals(fieldVO.getDatatype())) {
				if(StringUtils.isBlank(value)) {
					value = "0";
				}
				realValue = new UFDouble(value);
			} else if(DATATYPE.CHECKBOX.equals(fieldVO.getDatatype())) {
				// 逻辑框
				realValue = getCheckboxValue(value);
			} else if(DATATYPE.SELECT.equals(fieldVO.getDatatype())) {
				// 下拉
				realValue = UiTempletUtils.getSelectValue(value, fieldVO.getReftype());
				if(realValue != null) {
					// 对于下拉，再根据字段属性去判断,经常下拉返回的数据是Integer
					Field field = ReflectionUtils.findField(superVO.getClass(), fieldVO.getItemkey());
					if(field != null) {
						realValue = this.getRealValue(realValue.toString(), field);
					}
				}
			} else if(DATATYPE.DATE.equals(fieldVO.getDatatype())) {
				realValue = new UFDate(value);
				Field field = ReflectionUtils.findField(superVO.getClass(), fieldVO.getItemkey());
				if(field != null) {
					realValue = this.getRealValue(realValue.toString(), field);
				}
			} else if(DATATYPE.TIMESTAMP.equals(fieldVO.getDatatype())) {
				realValue = new UFDateTime(value);
				// 有些情况下可能UFDateTime类型，但是实际的字段类型是string，如发货单的“要求提货日期”，“要求到货日期”
				Field field = ReflectionUtils.findField(superVO.getClass(), fieldVO.getItemkey());
				if(field != null) {
					realValue = this.getRealValue(realValue.toString(), field);
				}
			} else if(DATATYPE.REF.equals(fieldVO.getDatatype())) {
				// 参照
				String refclass = DataTypeConverter.getRefClazz(fieldVO.getReftype(), fieldVO.getDatatype());
				BaseRefModel refModel = null;
				Class<?> clazz = Class.forName(refclass);
				Object obj = clazz.newInstance();
				if(obj instanceof IMultiSelect) {
					// 如果是多选类型
					IMultiSelect multiSelect = (IMultiSelect) obj;
					String consult_code = multiSelect.getConsult_code();
					if(StringUtils.isNotBlank(consult_code)) {
						if(value.startsWith("[") && value.endsWith("]")) {
							value = value.substring(1, value.length() - 1);
						}
						String[] valueAry = value.split(",");
						if(valueAry.length > 0) {
							StringBuffer buf = new StringBuffer();
							buf.append("[");
							for(int i = 0; i < valueAry.length; i++) {
								buf.append(UiTempletUtils.getSelectValue(valueAry[i], consult_code));
								if(i != valueAry.length - 1) {
									buf.append("]");
								}
							}
							realValue = buf.toString();
						}
					}
				} else {
					// 参照
					refModel = (BaseRefModel) obj;
					// 这里会根据code以及name去查询,如果返回多个值，不处理
					Map<String, Object> dataMap = refModel.getByCode(value);
					Object dataObj = dataMap.get("data");
					if(dataObj == null) {
						return null;
					}
					if(dataObj instanceof List) {// 如果返回多条记录，这里只取第一条
						List list = (List) dataObj;
						dataObj = list.get(0);
					}
					if(dataObj instanceof SuperVO) {
						SuperVO vo = (SuperVO) dataObj;
						realValue = RefUtils.convert(refModel, vo);// 此时的realValue是一个refVO
					} else {
						Map map = (Map) dataObj;
						realValue = RefUtils.convert(refModel, map);// 此时的realValue是一个refVO
					}
				}
			}
		} catch(Exception e) {
			String error = "Excel中单元格的数据值解析错误，值：" + value + "，错误信息：" + e.getMessage();
			logger.error(error);
			throw new BusiException(error);
		}
		return realValue;
	}

	/**
	 * 逻辑框的值，页面上一般写的是“是、Y、1”等
	 * 
	 * @param value
	 * @return
	 */
	protected UFBoolean getCheckboxValue(String value) {
		if("是".equals(value) || "Y".equalsIgnoreCase(value) || "1".equals(value)) {
			return UFBoolean.TRUE;
		}
		return UFBoolean.FALSE;
	}

	/**
	 * 获取单元格数据内容为字符串类型的数据
	 * 
	 * @param cell
	 * @return
	 */
	protected String getStringCellValue(Cell cell) {
		if(cell == null) {
			return "";
		}
		String strCell = "";
		switch(cell.getCellType()){
		case Cell.CELL_TYPE_STRING:
			strCell = cell.getStringCellValue();
			break;
		case Cell.CELL_TYPE_NUMERIC:
			// 对于日期格式，读取后也是属于数字类型，这里需要处理
			if(HSSFDateUtil.isCellDateFormatted(cell)) {// 处理日期格式、时间格式
				Date date = cell.getDateCellValue();
				// if(cell.getCellStyle().getDataFormat() ==
				// HSSFDataFormat.getBuiltinFormat("h:mm")) {
				// // 时间类型
				// } else {
				// // 日期类型
				// }
				strCell = DateUtils.formatDate(date, DateUtils.DATETIME_FORMAT_HORIZONTAL);
			} else {
				strCell = String.valueOf(cell.getNumericCellValue());
			}
			break;
		case Cell.CELL_TYPE_BOOLEAN:
			strCell = String.valueOf(cell.getBooleanCellValue());
			break;
		case Cell.CELL_TYPE_BLANK:
			strCell = "";
			break;
		default:
			strCell = "";
			break;
		}
		return strCell.trim();
	}

	public static void main(String[] args) {
		String str = "[132]";
		System.out.println(str.substring(1, str.length() - 1));
	}
}
